package action.chap3;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class InterFaceFunction {
    public static void main(String[] args) {
        List<String> listOfStrings = Arrays.asList("111", "222", "");
        // Predicate
        List<String> filter = filter(listOfStrings, s -> !s.isEmpty());
        System.out.println(filter);

        forEach(listOfStrings, System.out::println);
        //由Iterable接口中
        listOfStrings.forEach(System.out::println);

        List<Integer> l = map(
                Arrays.asList("lambdas","in","action"),
                (String s) -> s.length()
        );
        System.out.println(l);
    }

    //在你需要表示一个涉及类型T的布尔表达式时，就可以使用Predicate这个接口。
    // 定义泛型类型的函数  这个就是集合中filter实现原理
    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> results = new ArrayList<>();
        for (T s : list) {
            if (p.test(s)) {
                results.add(s);
            }
        }
        return results;
    }

    //你如果需要访问类型T的对象，并对其执行某些操作，就可以使用Consumer这个接口。
    public static <T> void forEach(List<T> list, Consumer<T> c) {
        for (T s : list) {
            c.accept(s);
        }
    }
    public static <T, R> List<R> map(List<T> list,
                                     Function<T, R> f) {
        List<R> result = new ArrayList<>();
        for(T s: list){
            result.add(f.apply(s));
        }
        return result;
    }
}
